{
 "cells": [
  {
   "cell_type": "code",
   "id": "6b05e60b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:54:34.088185Z",
     "start_time": "2025-08-21T06:54:34.079408Z"
    }
   },
   "source": "#!pip install gym==0.25.2",
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "code",
   "id": "141804bd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:54:35.220861Z",
     "start_time": "2025-08-21T06:54:34.088185Z"
    }
   },
   "source": [
    "!pip list|grep gym"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gym                       0.25.2\n",
      "gym-notices               0.1.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "[notice] A new release of pip is available: 24.0 -> 25.2\n",
      "[notice] To update, run: python.exe -m pip install --upgrade pip\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "id": "5dd0d0e5-d13e-4bca-ace9-fdcc2868b184",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:54:36.881126Z",
     "start_time": "2025-08-21T06:54:35.220861Z"
    }
   },
   "source": [
    "import random\n",
    "import gym\n",
    "import numpy as np\n",
    "import collections\n",
    "from tqdm import tqdm\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "import rl_utils"
   ],
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Gym has been unmaintained since 2022 and does not support NumPy 2.0 amongst other critical functionality.\n",
      "Please upgrade to Gymnasium, the maintained drop-in replacement of Gym, or contact the authors of your software and request that they upgrade.\n",
      "See the migration guide at https://gymnasium.farama.org/introduction/migration_guide/ for additional information.\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "code",
   "id": "adee35e5-10a3-4cb0-b198-de1c7bc0e294",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:54:36.885292Z",
     "start_time": "2025-08-21T06:54:36.881126Z"
    }
   },
   "source": [
    "class ReplayBuffer:\n",
    "    ''' 经验回放池 '''\n",
    "    def __init__(self, capacity):\n",
    "        self.buffer = collections.deque(maxlen=capacity)  # 队列,先进先出，设置最大容量\n",
    "\n",
    "    def add(self, state, action, reward, next_state, done):  # 将数据加入buffer\n",
    "        self.buffer.append((state, action, reward, next_state, done))  # 将转移元组作为一个整体添加到缓冲区\n",
    "\n",
    "    def sample(self, batch_size):  # 从buffer中采样数据,数量为batch_size\n",
    "        transitions = random.sample(self.buffer, batch_size)  # 随机采样指定数量的转移元组\n",
    "        state, action, reward, next_state, done = zip(*transitions)  # 解压所有转移元组，按类型分组\n",
    "        return np.array(state), action, reward, np.array(next_state), done  # 返回批量数据，状态数据转换为numpy数组\n",
    "\n",
    "    def size(self):  # 目前buffer中数据的数量\n",
    "        return len(self.buffer)  # 返回当前缓冲区中的样本数量"
   ],
   "outputs": [],
   "execution_count": 4
  },
  {
   "cell_type": "code",
   "id": "6f732111-2a15-4c6f-bf82-1bf5ae0d5c98",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:54:36.889255Z",
     "start_time": "2025-08-21T06:54:36.885292Z"
    }
   },
   "source": [
    "class Qnet(torch.nn.Module):\n",
    "    ''' 只有一层隐藏层的Q网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(Qnet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))  # 隐藏层使用ReLU激活函数\n",
    "        return self.fc2(x)"
   ],
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "id": "d6b11fc2-28e6-49d0-ae8d-139373888d66",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:54:36.895586Z",
     "start_time": "2025-08-21T06:54:36.889255Z"
    }
   },
   "source": [
    "class DQN:\n",
    "    ''' DQN算法 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma,\n",
    "                 epsilon, target_update, device):\n",
    "        self.action_dim = action_dim  # 动作空间维度\n",
    "        self.q_net = Qnet(state_dim, hidden_dim,\n",
    "                          self.action_dim).to(device)  # 创建主Q网络并移至指定设备\n",
    "        # 创建目标网络并移至指定设备\n",
    "        self.target_q_net = Qnet(state_dim, hidden_dim,\n",
    "                                 self.action_dim).to(device)\n",
    "        # 使用Adam优化器，优化主Q网络的参数\n",
    "        self.optimizer = torch.optim.Adam(self.q_net.parameters(),\n",
    "                                          lr=learning_rate)\n",
    "        self.gamma = gamma  # 折扣因子，用于计算未来奖励的现值\n",
    "        self.epsilon = epsilon  # epsilon-贪婪策略的探索率\n",
    "        self.target_update = target_update  # 目标网络更新频率\n",
    "        self.count = 0  # 计数器，记录更新次数，用于确定何时更新目标网络\n",
    "        self.device = device  # 计算设备（CPU或GPU）\n",
    "\n",
    "    def take_action(self, state):  # epsilon-贪婪策略采取动作\n",
    "        if np.random.random() < self.epsilon:  # 以epsilon的概率随机选择动作（探索）\n",
    "            action = np.random.randint(self.action_dim)  # 随机选择一个动作\n",
    "        else:  # 以1-epsilon的概率选择当前最优动作（利用）\n",
    "            if isinstance(state, tuple):  # 检查状态是否为元组\n",
    "                state = state[0]  # 如果state是元组，提取第一个元素\n",
    "            state = torch.tensor(state, dtype=torch.float).unsqueeze(0).to(self.device)  # 将状态转换为张量并添加batch维度\n",
    "            action = self.q_net(state).argmax().item()  # 选择Q值最大的动作\n",
    "        return action  # 返回选择的动作\n",
    "\n",
    "    def update(self, transition_dict):  # 更新Q网络\n",
    "        states = torch.tensor(transition_dict['states'],\n",
    "                              dtype=torch.float).to(self.device)  # 将状态转换为张量并移至设备\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(\n",
    "            self.device)  # 将动作转换为张量并调整形状\n",
    "        rewards = torch.tensor(transition_dict['rewards'],\n",
    "                               dtype=torch.float).view(-1, 1).to(self.device)  # 将奖励转换为张量并调整形状\n",
    "        next_states = torch.tensor(transition_dict['next_states'],\n",
    "                                   dtype=torch.float).to(self.device)  # 将下一状态转换为张量并移至设备\n",
    "        dones = torch.tensor(transition_dict['dones'],\n",
    "                             dtype=torch.float).view(-1, 1).to(self.device)  # 将终止标志转换为张量并调整形状\n",
    "\n",
    "        q_values = self.q_net(states).gather(1, actions)  # 获取当前状态-动作对的Q值\n",
    "        # 计算下一状态的最大Q值\n",
    "        max_next_q_values = self.target_q_net(next_states).max(1)[0].view(\n",
    "            -1, 1)\n",
    "        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones)  # 计算TD目标值\n",
    "        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))  # 计算均方误差损失\n",
    "        self.optimizer.zero_grad()  # 清除之前的梯度\n",
    "        dqn_loss.backward()  # 反向传播计算梯度\n",
    "        self.optimizer.step()  # 更新网络参数\n",
    "\n",
    "        if self.count % self.target_update == 0:  # 每隔target_update次更新目标网络\n",
    "            self.target_q_net.load_state_dict(\n",
    "                self.q_net.state_dict())  # 将主网络的参数复制到目标网络\n",
    "        self.count += 1  # 更新计数器"
   ],
   "outputs": [],
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "id": "e5ad350d-fd84-403d-9a70-9480c002250b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:54:36.898330Z",
     "start_time": "2025-08-21T06:54:36.895586Z"
    }
   },
   "source": [
    "# transition_dict['states'][0]"
   ],
   "outputs": [],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "id": "ddc79828-4ae4-4e88-bc34-a08fdc7c3845",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:54:36.900949Z",
     "start_time": "2025-08-21T06:54:36.898330Z"
    }
   },
   "source": [
    "# states = torch.tensor(transition_dict['states'],\n",
    "#                               dtype=torch.float)\n",
    "# states.shape"
   ],
   "outputs": [],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "id": "41905252-cbc7-492a-8194-6a9318811844",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:56:54.874064Z",
     "start_time": "2025-08-21T06:54:39.245620Z"
    }
   },
   "source": [
    "lr = 2e-3  # 设置学习率\n",
    "num_episodes = 500  # 设置总训练回合数\n",
    "hidden_dim = 128  # 设置神经网络隐藏层维度\n",
    "gamma = 0.98  # 设置折扣因子\n",
    "epsilon = 0.01  # 设置探索率\n",
    "target_update = 10  # 设置目标网络更新频率\n",
    "buffer_size = 10000  # 设置经验回放缓冲区大小\n",
    "minimal_size = 500  # 设置开始训练的最小缓冲区大小\n",
    "batch_size = 64  # 设置批量大小\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\n",
    "    \"cpu\")  # 设置计算设备，优先使用GPU\n",
    "\n",
    "env_name = 'CartPole-v0'  # 设置环境名称\n",
    "env = gym.make(env_name)  # 创建OpenAI Gym环境\n",
    "random.seed(0)  # 设置随机种子\n",
    "np.random.seed(0)  # 设置numpy随机种子\n",
    "env.reset(seed=0)  # 重置环境并设置环境随机种子\n",
    "\n",
    "torch.manual_seed(0)  # 设置PyTorch随机种子\n",
    "replay_buffer = ReplayBuffer(buffer_size)  # 创建经验回放缓冲区\n",
    "state_dim = env.observation_space.shape[0]  # 获取状态空间维度\n",
    "print(f'state_dim:{state_dim}')\n",
    "action_dim = env.action_space.n  # 获取动作空间维度\n",
    "print(f'action_dim:{action_dim}')\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon,\n",
    "            target_update, device)  # 创建DQN智能体\n",
    "\n",
    "return_list = []  # 创建存储每个回合回报的列表\n",
    "for i in range(10):  # 将总回合分为10组进行训练\n",
    "    with tqdm(total=int(num_episodes / 10), desc='Iteration %d' % i) as pbar:  # 创建进度条\n",
    "        for i_episode in range(int(num_episodes / 10)):  # 每组训练num_episodes/10个回合\n",
    "            episode_return = 0  # 初始化当前回合的累积回报\n",
    "            state = env.reset()  # 重置环境，获取初始状态\n",
    "            done = False  # 初始化回合结束标志\n",
    "            while not done:  # 当回合未结束时循环\n",
    "                action = agent.take_action(state)  # 智能体根据当前状态选择动作\n",
    "                next_state, reward, done, _ = env.step(action)  # 执行动作，获取下一状态、奖励和是否结束\n",
    "                replay_buffer.add(state, action, reward, next_state, done)  # 将转移元组添加到经验回放缓冲区\n",
    "                state = next_state  # 更新当前状态\n",
    "                episode_return += reward  # 累加奖励\n",
    "                # 当buffer数据的数量超过一定值后,才进行Q网络训练\n",
    "                if replay_buffer.size() > minimal_size:  # 当缓冲区大小超过最小值时开始训练\n",
    "                    b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(batch_size)  # 从缓冲区采样一批数据\n",
    "                    transition_dict = {  # 创建转移字典\n",
    "                        'states': b_s,  # 状态\n",
    "                        'actions': b_a,  # 动作\n",
    "                        'next_states': b_ns,  # 下一状态\n",
    "                        'rewards': b_r,  # 奖励\n",
    "                        'dones': b_d  # 是否结束\n",
    "                    }\n",
    "                    agent.update(transition_dict)  # 更新智能体的Q网络\n",
    "            return_list.append(episode_return)  # 将当前回合的累积回报添加到列表中\n",
    "            if (i_episode + 1) % 10 == 0:  # 每10个回合更新一次进度条信息\n",
    "                pbar.set_postfix({\n",
    "                    'episode':\n",
    "                    '%d' % (num_episodes / 10 * i + i_episode + 1),  # 显示当前回合数\n",
    "                    'return':\n",
    "                    '%.3f' % np.mean(return_list[-10:])  # 显示最近10个回合的平均回报\n",
    "                })\n",
    "            pbar.update(1)  # 更新进度条"
   ],
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\YuBin\\AppData\\Roaming\\Python\\Python312\\site-packages\\gym\\envs\\registration.py:593: UserWarning: \u001B[33mWARN: The environment CartPole-v0 is out of date. You should consider upgrading to version `v1`.\u001B[0m\n",
      "  logger.warn(\n",
      "C:\\Users\\YuBin\\AppData\\Roaming\\Python\\Python312\\site-packages\\gym\\core.py:317: DeprecationWarning: \u001B[33mWARN: Initializing wrapper in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001B[0m\n",
      "  deprecation(\n",
      "C:\\Users\\YuBin\\AppData\\Roaming\\Python\\Python312\\site-packages\\gym\\wrappers\\step_api_compatibility.py:39: DeprecationWarning: \u001B[33mWARN: Initializing environment in old step API which returns one bool instead of two. It is recommended to set `new_step_api=True` to use new step API. This will be the default behaviour in future.\u001B[0m\n",
      "  deprecation(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "state_dim:4\n",
      "action_dim:2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|██████████| 50/50 [00:00<00:00, 219.41it/s, episode=50, return=9.000]\n",
      "Iteration 1: 100%|██████████| 50/50 [00:01<00:00, 36.82it/s, episode=100, return=14.500]\n",
      "Iteration 2: 100%|██████████| 50/50 [00:06<00:00,  7.40it/s, episode=150, return=124.900]\n",
      "Iteration 3: 100%|██████████| 50/50 [00:16<00:00,  2.97it/s, episode=200, return=165.300]\n",
      "Iteration 4: 100%|██████████| 50/50 [00:18<00:00,  2.66it/s, episode=250, return=157.100]\n",
      "Iteration 5: 100%|██████████| 50/50 [00:18<00:00,  2.70it/s, episode=300, return=186.100]\n",
      "Iteration 6: 100%|██████████| 50/50 [00:18<00:00,  2.74it/s, episode=350, return=170.500]\n",
      "Iteration 7: 100%|██████████| 50/50 [00:18<00:00,  2.66it/s, episode=400, return=195.900]\n",
      "Iteration 8: 100%|██████████| 50/50 [00:17<00:00,  2.89it/s, episode=450, return=147.100]\n",
      "Iteration 9: 100%|██████████| 50/50 [00:17<00:00,  2.85it/s, episode=500, return=187.800]\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "id": "16a85cbf-83f1-4d41-905c-808516c098d8",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-08-21T06:58:33.757855Z",
     "start_time": "2025-08-21T06:58:33.569059Z"
    }
   },
   "source": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('DQN on {}'.format(env_name))\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('DQN on {}'.format(env_name))\n",
    "plt.show()"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 10
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
